home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / os / sprite / utils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-24  |  16.7 KB  |  692 lines
  1. /***********************************************************
  2. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
  3. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Digital or MIT not be
  12. used in advertising or publicity pertaining to distribution of the
  13. software without specific, written prior permission.  
  14.  
  15. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21. SOFTWARE.
  22.  
  23. ******************************************************************/
  24. /* $XConsortium: utils.c,v 1.89 89/12/13 09:10:53 rws Exp $ */
  25. #include <stdio.h>
  26. #include "Xos.h"
  27. #include "misc.h"
  28. #include "X.h"
  29. #include "input.h"
  30. #include "opaque.h"
  31. #include <sys/signal.h>
  32. extern char *display;
  33.  
  34. extern long defaultScreenSaverTime;    /* for parsing command line */
  35. extern long defaultScreenSaverInterval;
  36. extern int defaultScreenSaverBlanking;
  37. extern int defaultBackingStore;
  38. extern Bool disableBackingStore;
  39. extern Bool disableSaveUnders;
  40. #ifndef NOLOGOHACK
  41. extern int logoScreenSaver;
  42. #endif
  43. #ifndef SYSV
  44. extern int limitDataSpace, limitStackSpace;
  45. #endif
  46. extern int defaultColorVisualClass;
  47. extern long ScreenSaverTime;        /* for forcing reset */
  48. extern Bool permitOldBugs;
  49. extern int monitorResolution;
  50.  
  51. void ddxUseMsg();
  52.  
  53. extern char *sbrk();
  54.  
  55. #ifdef DEBUG
  56. #ifndef SPECIAL_MALLOC
  57. #define MEMBUG
  58. #endif
  59. #endif
  60.  
  61. #ifdef MEMBUG
  62. #define MEM_FAIL_SCALE 100000
  63. long Memory_fail = 0;
  64. static pointer minfree = NULL;
  65. static void CheckNode();
  66. #endif
  67.  
  68. Bool Must_have_memory = FALSE;
  69.  
  70. char *dev_tty_from_init = NULL;        /* since we need to parse it anyway */
  71.  
  72. /* Force connections to close on SIGHUP from init */
  73.  
  74. AutoResetServer ()
  75. {
  76.     dispatchException |= DE_RESET;
  77.     isItTimeToYield = TRUE;
  78. #ifdef GPROF
  79.     chdir ("/tmp");
  80.     exit (0);
  81. #endif
  82. #ifdef SYSV
  83.     signal (SIGHUP, AutoResetServer);
  84. #endif
  85. }
  86.  
  87. /* Force connections to close and then exit on SIGTERM, SIGINT */
  88.  
  89. GiveUp()
  90. {
  91.     dispatchException |= DE_TERMINATE;
  92.     isItTimeToYield = TRUE;
  93. }
  94.  
  95.  
  96. static void
  97. AbortServer()
  98. {
  99.     extern void AbortDDX();
  100.  
  101.     AbortDDX();
  102.     fflush(stderr);
  103.     abort();
  104. }
  105.  
  106. void
  107. Error(str)
  108.     char *str;
  109. {
  110.     perror(str);
  111. }
  112.  
  113. #if defined (UTEK) || defined (UTEKV)
  114. /*
  115.  * Tektronix has a shared-memory time value which doesn't
  116.  * match gettimeofday at all, but it is only accessible
  117.  * inside the driver.
  118.  */
  119. #else
  120. long
  121. GetTimeInMillis()
  122. {
  123.     struct timeval  tp;
  124.  
  125.     gettimeofday(&tp, 0);
  126.     return(tp.tv_sec * 1000) + (tp.tv_usec / 1000);
  127. }
  128. #endif
  129.  
  130. void UseMsg()
  131. {
  132. #if !defined(AIXrt) && !defined(AIX386)
  133.     ErrorF("use: X [:<display>] [option]\n");
  134.     ErrorF("-a #                   mouse acceleration (pixels)\n");
  135. #ifdef MEMBUG
  136.     ErrorF("-alloc int             chance alloc should fail\n");
  137. #endif
  138.     ErrorF("-auth string           select authorization file\n");    
  139.     ErrorF("bc                     enable bug compatibility\n");
  140.     ErrorF("-bs                    disable any backing store support\n");
  141.     ErrorF("-c                     turns off key-click\n");
  142.     ErrorF("c #                    key-click volume (0-100)\n");
  143.     ErrorF("-cc int                default color visual class\n");
  144.     ErrorF("-co string             color database file\n");
  145.     ErrorF("-dpi int               screen resolution in dots per inch\n");
  146.     ErrorF("-f #                   bell base (0-100)\n");
  147.     ErrorF("-fc string             cursor font\n");
  148.     ErrorF("-fn string             default font name\n");
  149.     ErrorF("-fp string             default font path\n");
  150.     ErrorF("-help                  prints message with these options\n");
  151.     ErrorF("-I                     ignore all remaining arguments\n");
  152. #ifndef SYSV
  153.     ErrorF("-ld int                limit data space to N Kb\n");
  154.     ErrorF("-ls int                limit stack space to N Kb\n");
  155. #endif
  156. #ifndef NOLOGOHACK
  157.     ErrorF("-logo                  enable logo in screen saver\n");
  158.     ErrorF("nologo                 disable logo in screen saver\n");
  159. #endif
  160.     ErrorF("-p #                   screen-saver pattern duration (seconds)\n");
  161.     ErrorF("-r                     turns off auto-repeat\n");
  162.     ErrorF("r                      turns on auto-repeat \n");
  163.     ErrorF("-s #                   screen-saver timeout (seconds)\n");
  164.     ErrorF("-su                    disable any save under support\n");
  165.     ErrorF("-t #                   mouse threshold (pixels)\n");
  166.     ErrorF("-to #                  connection time out\n");
  167.     ErrorF("ttyxx                  server started from init on /dev/ttyxx\n");
  168.     ErrorF("v                      video blanking for screen-saver\n");
  169.     ErrorF("-v                     screen-saver without video blanking\n");
  170.     ErrorF("-wm                    WhenMapped default backing-store\n");
  171.     ErrorF("-x string              loads named extension at init time \n");
  172. #ifdef XDMCP
  173.     XdmcpUseMsg();
  174. #endif
  175. #endif /* !AIXrt && ! AIX386 */
  176.     ddxUseMsg();
  177. }
  178.  
  179. /*
  180.  * This function parses the command line. Handles device-independent fields
  181.  * and allows ddx to handle additional fields.  It is not allowed to modify
  182.  * argc or any of the strings pointed to by argv.
  183.  */
  184. void
  185. ProcessCommandLine ( argc, argv )
  186. int    argc;
  187. char    *argv[];
  188.  
  189. {
  190.     int i, skip;
  191.  
  192. #ifdef MEMBUG
  193.     if (!minfree)
  194.     minfree = (pointer)sbrk(0);
  195. #endif
  196.     defaultKeyboardControl.autoRepeat = TRUE;
  197.     permitOldBugs = TRUE;
  198.     for ( i = 1; i < argc; i++ )
  199.     {
  200.     /* call ddx first, so it can peek/override if it wants */
  201.         if(skip = ddxProcessArgument(argc, argv, i))
  202.     {
  203.         i += (skip - 1);
  204.     }
  205.     else if(argv[i][0] ==  ':')  
  206.     {
  207.         /* initialize display */
  208.         display = argv[i];
  209.         display++;
  210.     }
  211.     else if ( strcmp( argv[i], "-a") == 0)
  212.     {
  213.         if(++i < argc)
  214.             defaultPointerControl.num = atoi(argv[i]);
  215.         else
  216.         UseMsg();
  217.     }
  218. #ifdef MEMBUG
  219.     else if ( strcmp( argv[i], "-alloc") == 0)
  220.     {
  221.         if(++i < argc)
  222.             Memory_fail = atoi(argv[i]);
  223.         else
  224.         UseMsg();
  225.     }
  226. #endif
  227.     else if ( strcmp( argv[i], "-auth") == 0)
  228.     {
  229.         if(++i < argc)
  230.             InitAuthorization (argv[i]);
  231.         else
  232.         UseMsg();
  233.     }
  234.     else if ( strcmp( argv[i], "bc") == 0)
  235.         permitOldBugs = TRUE;
  236.     else if ( strcmp( argv[i], "-bs") == 0)
  237.         disableBackingStore = TRUE;
  238.     else if ( strcmp( argv[i], "c") == 0)
  239.     {
  240.         if(++i < argc)
  241.             defaultKeyboardControl.click = atoi(argv[i]);
  242.         else
  243.         UseMsg();
  244.     }
  245.     else if ( strcmp( argv[i], "-c") == 0)
  246.     {
  247.         defaultKeyboardControl.click = 0;
  248.     }
  249.     else if ( strcmp( argv[i], "-cc") == 0)
  250.     {
  251.         if(++i < argc)
  252.             defaultColorVisualClass = atoi(argv[i]);
  253.         else
  254.         UseMsg();
  255.     }
  256.     else if ( strcmp( argv[i], "-co") == 0)
  257.     {
  258.         if(++i < argc)
  259.             rgbPath = argv[i];
  260.         else
  261.         UseMsg();
  262.     }
  263.     else if ( strcmp( argv[i], "-dpi") == 0)
  264.     {
  265.         if(++i < argc)
  266.             monitorResolution = atoi(argv[i]);
  267.         else
  268.         UseMsg();
  269.     }
  270.     else if ( strcmp( argv[i], "-f") == 0)
  271.     {
  272.         if(++i < argc)
  273.             defaultKeyboardControl.bell = atoi(argv[i]);
  274.         else
  275.         UseMsg();
  276.     }
  277.     else if ( strcmp( argv[i], "-fc") == 0)
  278.     {
  279.         if(++i < argc)
  280.             defaultCursorFont = argv[i];
  281.         else
  282.         UseMsg();
  283.     }
  284.     else if ( strcmp( argv[i], "-fn") == 0)
  285.     {
  286.         if(++i < argc)
  287.             defaultTextFont = argv[i];
  288.         else
  289.         UseMsg();
  290.     }
  291.     else if ( strcmp( argv[i], "-fp") == 0)
  292.     {
  293.         if(++i < argc)
  294.             defaultFontPath = argv[i];
  295.         else
  296.         UseMsg();
  297.     }
  298.     else if ( strcmp( argv[i], "-help") == 0)
  299.     {
  300.         UseMsg();
  301.         exit(0);
  302.     }
  303. #ifndef SYSV
  304.     else if ( strcmp( argv[i], "-ld") == 0)
  305.     {
  306.         if(++i < argc)
  307.         {
  308.             limitDataSpace = atoi(argv[i]);
  309.         if (limitDataSpace > 0)
  310.             limitDataSpace *= 1024;
  311.         }
  312.         else
  313.         UseMsg();
  314.     }
  315.     else if ( strcmp( argv[i], "-ls") == 0)
  316.     {
  317.         if(++i < argc)
  318.         {
  319.             limitStackSpace = atoi(argv[i]);
  320.         if (limitStackSpace > 0)
  321.             limitStackSpace *= 1024;
  322.         }
  323.         else
  324.         UseMsg();
  325.     }
  326. #endif
  327. #ifndef NOLOGOHACK
  328.     else if ( strcmp( argv[i], "-logo") == 0)
  329.     {
  330.         logoScreenSaver = 1;
  331.     }
  332.     else if ( strcmp( argv[i], "nologo") == 0)
  333.     {
  334.         logoScreenSaver = 0;
  335.     }
  336. #endif
  337.     else if ( strcmp( argv[i], "-p") == 0)
  338.     {
  339.         if(++i < argc)
  340.             defaultScreenSaverInterval = ((long)atoi(argv[i])) *
  341.                          MILLI_PER_MIN;
  342.         else
  343.         UseMsg();
  344.     }
  345.     else if ( strcmp( argv[i], "r") == 0)
  346.         defaultKeyboardControl.autoRepeat = TRUE;
  347.     else if ( strcmp( argv[i], "-r") == 0)
  348.         defaultKeyboardControl.autoRepeat = FALSE;
  349.     else if ( strcmp( argv[i], "-s") == 0)
  350.     {
  351.         if(++i < argc)
  352.             defaultScreenSaverTime = ((long)atoi(argv[i])) * MILLI_PER_MIN;
  353.         else
  354.         UseMsg();
  355.     }
  356.     else if ( strcmp( argv[i], "-su") == 0)
  357.         disableSaveUnders = TRUE;
  358.     else if ( strcmp( argv[i], "-t") == 0)
  359.     {
  360.         if(++i < argc)
  361.             defaultPointerControl.threshold = atoi(argv[i]);
  362.         else
  363.         UseMsg();
  364.     }
  365.     else if ( strcmp( argv[i], "-to") == 0)
  366.     {
  367.         if(++i < argc)
  368.         TimeOutValue = ((long)atoi(argv[i])) * MILLI_PER_SECOND;
  369.         else
  370.         UseMsg();
  371.     }
  372.     else if ( strcmp( argv[i], "v") == 0)
  373.         defaultScreenSaverBlanking = PreferBlanking;
  374.     else if ( strcmp( argv[i], "-v") == 0)
  375.         defaultScreenSaverBlanking = DontPreferBlanking;
  376.     else if ( strcmp( argv[i], "-wm") == 0)
  377.         defaultBackingStore = WhenMapped;
  378.     else if ( strcmp( argv[i], "-x") == 0)
  379.     {
  380.         if(++i >= argc)
  381.         UseMsg();
  382.         /* For U**x, which doesn't support dynamic loading, there's nothing
  383.          * to do when we see a -x.  Either the extension is linked in or
  384.          * it isn't */
  385.     }
  386.     else if ( strcmp( argv[i], "-I") == 0)
  387.     {
  388.         /* ignore all remaining arguments */
  389.         break;
  390.     }
  391.     else if (strncmp (argv[i], "tty", 3) == 0)
  392.     {
  393.         /* just in case any body is interested */
  394.         dev_tty_from_init = argv[i];
  395.     }
  396. #ifdef XDMCP
  397.     else if ((skip = XdmcpOptions(argc, argv, i)) != i)
  398.     {
  399.         i = skip - 1;
  400.     }
  401. #endif
  402.      else
  403.      {
  404.         UseMsg();
  405.         exit (1);
  406.         }
  407.     }
  408. }
  409.  
  410. #ifndef SPECIAL_MALLOC
  411.  
  412. #ifdef MEMBUG
  413. #define FIRSTMAGIC 0x11aaaa11
  414. #define SECONDMAGIC 0x22aaaa22
  415. #define FREEDMAGIC  0x33aaaa33
  416.  
  417. typedef struct _MallocHeader    *MallocHeaderPtr;
  418.  
  419. typedef struct _MallocHeader {
  420.     unsigned long    amount;
  421.     unsigned long    time;
  422.     MallocHeaderPtr    prev;
  423.     MallocHeaderPtr    next;
  424.     unsigned long    magic;
  425. } MallocHeaderRec;
  426.  
  427. typedef struct _MallocTrailer {
  428.     unsigned long    magic;
  429. } MallocTrailerRec, *MallocTrailerPtr;
  430.  
  431. unsigned long    MemoryAllocTime;
  432. unsigned long    MemoryAllocBreakpoint = ~0;
  433. unsigned long    MemoryActive = 0;
  434. unsigned long    MemoryValidate;
  435.  
  436. MallocHeaderPtr    MemoryInUse;
  437.  
  438. #define request(amount)    ((amount) + sizeof (MallocHeaderRec) + sizeof (MallocTrailerRec))
  439. #define Header(ptr)    ((MallocHeaderPtr) (((char *) ptr) - sizeof (MallocHeaderRec)))
  440. #define Trailer(ptr)    ((MallocTrailerPtr) (((char *) ptr) + Header(ptr)->amount))
  441.  
  442. static unsigned long *
  443. SetupBlock(ptr, amount)
  444.     unsigned long   *ptr;
  445. {
  446.     MallocHeaderPtr    head = (MallocHeaderPtr) ptr;
  447.     MallocTrailerPtr    tail = (MallocTrailerPtr) (((char *) ptr) + amount + sizeof (MallocHeaderRec));
  448.  
  449.     MemoryActive += amount;
  450.     head->magic = FIRSTMAGIC;
  451.     head->amount = amount;
  452.     if (MemoryAllocTime == MemoryAllocBreakpoint)
  453.     head->amount = amount;
  454.     head->time = MemoryAllocTime++;
  455.     head->next = MemoryInUse;
  456.     head->prev = 0;
  457.     if (MemoryInUse)
  458.     MemoryInUse->prev = head;
  459.     MemoryInUse = head;
  460.  
  461.     tail->magic = SECONDMAGIC;
  462.     
  463.     return (unsigned long *)(((char *) ptr) + sizeof (MallocHeaderRec));
  464. }
  465.  
  466. ValidateAllActiveMemory ()
  467. {
  468.     MallocHeaderPtr    head;
  469.     MallocTrailerPtr    tail;
  470.  
  471.     for (head = MemoryInUse; head; head = head->next)
  472.     {
  473.     tail = (MallocTrailerPtr) (((char *) (head + 1)) + head->amount);
  474.         if (head->magic == FREEDMAGIC)
  475.         FatalError("Free data on active list");
  476.         if(head->magic != FIRSTMAGIC || tail->magic != SECONDMAGIC)
  477.         FatalError("Garbage object on active list");
  478.     }
  479. }
  480.  
  481. #endif
  482.  
  483. /* XALLOC -- X's internal memory allocator.  Why does it return unsigned
  484.  * int * instead of the more common char *?  Well, if you read K&R you'll
  485.  * see they say that alloc must return a pointer "suitable for conversion"
  486.  * to whatever type you really want.  In a full-blown generic allocator
  487.  * there's no way to solve the alignment problems without potentially
  488.  * wasting lots of space.  But we have a more limited problem. We know
  489.  * we're only ever returning pointers to structures which will have to
  490.  * be long word aligned.  So we are making a stronger guarantee.  It might
  491.  * have made sense to make Xalloc return char * to conform with people's
  492.  * expectations of malloc, but this makes lint happier.
  493.  */
  494.  
  495. unsigned long * 
  496. Xalloc (amount)
  497.     unsigned long amount;
  498. {
  499.     char        *malloc();
  500.     register pointer  ptr;
  501.     
  502.     if(!amount)
  503.     return (unsigned long *)NULL;
  504.     /* aligned extra on long word boundary */
  505.     amount = (amount + 3) & ~3;
  506. #ifdef MEMBUG
  507.     if (MemoryValidate)
  508.     ValidateAllActiveMemory ();
  509.     if (!Must_have_memory && Memory_fail &&
  510.     ((random() % MEM_FAIL_SCALE) < Memory_fail))
  511.     return (unsigned long *)NULL;
  512.     if (ptr = (pointer)malloc(request(amount)))
  513.     return SetupBlock (ptr, amount);
  514. #else
  515.     if (ptr = (pointer)malloc(amount))
  516.     return (unsigned long *)ptr;
  517. #endif
  518.     if (Must_have_memory)
  519.     FatalError("Out of memory");
  520.     return (unsigned long *)NULL;
  521. }
  522.  
  523. /*****************
  524.  * Xcalloc
  525.  *****************/
  526.  
  527. unsigned long *
  528. Xcalloc (amount)
  529.     unsigned long   amount;
  530. {
  531.     unsigned long   *ret;
  532.  
  533.     ret = Xalloc (amount);
  534.     if (ret)
  535.     bzero ((char *) ret, (int) amount);
  536.     return ret;
  537. }
  538.  
  539. /*****************
  540.  * Xrealloc
  541.  *****************/
  542.  
  543. unsigned long *
  544. Xrealloc (ptr, amount)
  545.     register pointer ptr;
  546.     unsigned long amount;
  547. {
  548.     char *malloc();
  549.     char *realloc();
  550.  
  551. #ifdef MEMBUG
  552.     if (MemoryValidate)
  553.     ValidateAllActiveMemory ();
  554.     if (!amount)
  555.     {
  556.     Xfree(ptr);
  557.     return (unsigned long *)NULL;
  558.     }
  559.     if (!Must_have_memory && Memory_fail &&
  560.     ((random() % MEM_FAIL_SCALE) < Memory_fail))
  561.     return (unsigned long *)NULL;
  562.     amount = (amount + 3) & ~3;
  563.     if (ptr)
  564.     {
  565.     CheckNode(ptr);
  566.     ptr = (pointer)realloc((char *) Header (ptr), request(amount));
  567.     }
  568.     else
  569.     ptr = (pointer)malloc(request(amount));
  570.     if (ptr)
  571.     return SetupBlock (ptr, amount);
  572. #else
  573.     if (!amount)
  574.     {
  575.     if (ptr)
  576.         free(ptr);
  577.     return (unsigned long *)NULL;
  578.     }
  579.     amount = (amount + 3) & ~3;
  580.     if (ptr)
  581.         ptr = (pointer)realloc((char *)ptr, amount);
  582.     else
  583.     ptr = (pointer)malloc(amount);
  584.     if (ptr)
  585.         return (unsigned long *)ptr;
  586. #endif
  587.     if (Must_have_memory)
  588.     FatalError("Out of memory");
  589.     return (unsigned long *)NULL;
  590. }
  591.                     
  592. /*****************
  593.  *  Xfree
  594.  *    calls free 
  595.  *****************/    
  596.  
  597. void
  598. Xfree(ptr)
  599.     register pointer ptr;
  600. {
  601. #ifdef MEMBUG
  602.     if (MemoryValidate)
  603.     ValidateAllActiveMemory ();
  604.     if (ptr)
  605.     {
  606.     MallocHeaderPtr    head;
  607.  
  608.     CheckNode(ptr);
  609.     head = Header(ptr);
  610.     head->magic = FREEDMAGIC;
  611.     free ((char *) head);
  612.     }
  613. #else
  614.     if (ptr)
  615.     free((char *)ptr); 
  616. #endif
  617. }
  618.  
  619. #ifdef MEMBUG
  620. static void
  621. CheckNode(ptr)
  622.     pointer ptr;
  623. {
  624.     MallocHeaderPtr    head;
  625.     MallocHeaderPtr    f, prev;
  626.  
  627.     if (ptr < minfree)
  628.     FatalError("Trying to free static storage");
  629.     head = Header(ptr);
  630.     if (((pointer) head) < minfree)
  631.     FatalError("Trying to free static storage");
  632.     if (head->magic == FREEDMAGIC)
  633.     FatalError("Freeing something already freed");
  634.     if(head->magic != FIRSTMAGIC || Trailer(ptr)->magic != SECONDMAGIC)
  635.     FatalError("Freeing a garbage object");
  636.     if(head->prev)
  637.     head->prev->next = head->next;
  638.     else
  639.     MemoryInUse = head->next;
  640.     if (head->next)
  641.     head->next->prev = head->prev;
  642.     MemoryActive -= head->amount;
  643. }
  644.  
  645. DumpMemoryInUse (time)
  646.     unsigned long   time;
  647. {
  648.     MallocHeaderPtr    head;
  649.  
  650.     for (head = MemoryInUse; head; head = head->next)
  651.     if (head->time >= time)
  652.         printf ("0x%08x %5d %6d\n", head,
  653.                     head->amount,
  654.                     head->time);
  655. }
  656.  
  657. static unsigned long    MarkedTime;
  658.  
  659. MarkMemoryTime ()
  660. {
  661.     MarkedTime = MemoryAllocTime;
  662. }
  663.  
  664. DumpMemorySince ()
  665. {
  666.     DumpMemoryInUse (MarkedTime);
  667. }
  668. #endif
  669. #endif /* SPECIAL_MALLOC */
  670.  
  671. /*VARARGS1*/
  672. void
  673. FatalError(f, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) /* limit of ten args */
  674.     char *f;
  675.     char *s0, *s1, *s2, *s3, *s4, *s5, *s6, *s7, *s8, *s9;
  676. {
  677.     ErrorF("\nFatal server bug!\n");
  678.     ErrorF(f, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9);
  679.     ErrorF("\n");
  680.     AbortServer();
  681.     /*NOTREACHED*/
  682. }
  683.  
  684. /*VARARGS1*/
  685. void
  686. ErrorF( f, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) /* limit of ten args */
  687.     char *f;
  688.     char *s0, *s1, *s2, *s3, *s4, *s5, *s6, *s7, *s8, *s9;
  689. {
  690.     fprintf( stderr, f, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9);
  691. }
  692.